#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <wait.h>

using namespace std;

const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;

// 全局的命令行参数表
char *gargv[argvnum];// 全局的环境变量表
int gargc = 0; // 记录环境变量的个数

// 自己维护环境变量表
char *genv[envnum];

// 系统的环境变量默认是从配置文件来的【shell脚本】，
// 从系统里把系统环境变量拷一份到我的环境变量里面，模拟一下从配置文件里面去读

// 全局的当前shell工作路径 
char pwd[basesize];
char pwdenv[basesize];

string GetUserName()
{
    string user = getenv("USER");
    return user.empty() ? "None" : user;
}

string GetHostName()
{
    string hostname = getenv("HOSTNAME");
    return hostname.empty() ? "None" : hostname;
}

string GetPwd()
{ 
    // 获取当前的工作路径不能从环境变量里面获取，因为环境变量要更新
    // string pwd = getenv("PWD"); 
    // return pwd.empty() ? "None" : pwd;
 
    // 系统调用

    // 直接从系统里面获取环境变量
    // 获取完之后，把环境变量更新
    // getcwd(字符串，大小) 获取当前工作路径【系统级接口，直接从进程的PCB里面拿】被封装的接口gunc封装的接口
    // 失败返回值为NULL，成功就把当前工作路径写到buff里面
    
    // 1、获取当前工作路径
    if(nullptr == getcwd(pwd, sizeof(pwd))) return "None"; // 获得当前工作路径
    
    // 2、更新环境变量
    snprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);
    putenv(pwdenv); // PWD=XXXX
    return pwd;

// 环境变量是由shell自己维护的，即当路径发生变化时，环境变量表需要由shell自己去更新
// 我们可以更改环境变量的原因：shell支持用户自己去更改，shell本来就是为用户服务的
// shell不是从0开始读配置文件的，它时从系统的shell直接启动的，
// 所以我们写的shell启动的时候，它默认继承的是系统所对应的环境变量
// ./myshell它自己的环境变量，根本就没有维护环境变量表，
// 它的环境变量其实是从（父进程）系统的shell直接继承
//
// getenv 
//
// 环境变量表的指针数组，默认是在系统的shell的全局数组给我们维护好的，它也是一张全局的表
// putenv()实则就是在父进程所对应的全局指针数组里面，
// 找一个没有使用的位置，然后把这个环境变量加进来
//
// 导入到系统额shell里面，并不是子进程修改父进程的表，
// 因为发生修改时，会发生写时拷贝机制，
// 当子进程不修改，父子进程时共享的，一旦子进程进行修改，
// 操作系统就会对父shell的指针数组进行写时拷贝。【把整张表全部拷贝一份给子进程】
// 此时父子进程的环境变量表就是分开的

}

string MakeCommandLine()
{
    char command_line[basesize];// 输入的命令行长度
    // snprintf(写入到指定的缓冲区里,指定长度，按照指定的格式)
    snprintf(command_line, basesize, "[%s@%s %s]# ",\
            GetUserName().c_str(), GetHostName().c_str(), GetPwd().c_str());// c_str() 转化为C风格的字符串
        return command_line;
}

void PrintCommandLine()    // 1.命令行提示符
{
    printf("%s",MakeCommandLine().c_str());
    fflush(stdout);
}
         
bool GetCommandLine(char command_buffer[], int size)      // 2.获取用户命令
{
    // 从键盘当中获取出来的字符串，放到command_buffer缓冲区里面
    // 将用户输入的命令行，当作完整的字符串
    // "ls -a -l -n" 包括空格
    // fgets(获取字符串, 指定大小, 从特定的文件流当中获取) 获取失败返回null，获取成功返回获取成功的字符串的起始地址
    char *result = fgets(command_buffer, size, stdin);
    if(!result)
    {
        return false;
    }
    command_buffer[strlen(command_buffer)-1] = 0;// 最后输入的回车，把回车的字符改为0，字符串为空，即输入就是纯净版的没有换行
    if(strlen(command_buffer) == 0) return false; // 若输入为空，就终止
    return true;
}

void ParseCommandLine(char command_buffer[], int len)    // 3.分析命令
{
    (void)len;
    // 解析出来的命令，放到全局的环境变量表当中
    // strtok(一个字符串分多个，分隔符) 返回值：按照该分隔符从源字符串里切出来的第一个区域
    // strtok(str, " ");      如果切割有效的字符串，返回具体的字符串的第一个地址，
    // strtok(nullptr, " ");    否则，返回nullptr，即切到最后没有了，自动返回nullptr
    // "ls -a -l -n"
    memset(gargv, 0 , sizeof(gargv)); // 初始化/清空环境变量表里面的内容
    gargc = 0;

    const char *sep = " ";
    // 把首个子字符串拿出来
    gargv[gargc++] = strtok(command_buffer, sep);// 放到全局的环境列表里面
    
    // =是刻意写的  循环放入环境变量表中
    while((bool)(gargv[gargc++] = strtok(nullptr, sep)));
    gargc--;
}

void debug()
{
    printf("argc: %d\n",gargc);
    for(int i=0; gargv[i]; i++)
    {
        printf("argv[%d]: %s\n", i, gargv[i]);
    }
}

bool ExecuteCommand()      // 4.执行命令
{
    // shell 不能自己执行这个命令，如果shell可以自己执行命令，当命令错误的时候就全挂掉了，
    // shell是一个单进程的。
    // 让子进程执行命令
    pid_t id = fork();// 创建子进程
    if(id < 0) return false;
    if(id == 0)
    {
        // child
        // 1. 执行命令
        // exec*
        // execvp(gargv[0], gargv);
        // 在命令行当中输入的命令，是如何解析的？谁解析的?如何传递给目标子进程的？
        // shell来帮我们做解析，形成一张表，然后在进行程序替换的时候，
        // 直接以execvp的形式执行起来我的程序，并把这张表传递给对应的自己的进程
        
        // 如果我们在自己写的shell里面创建子进程，
        // 那这个子进程继承的环境变量表是父shell的，自己写的shell也是继承父shell的环境表
        // 那我们如何让我们自己写的shell，创建的子进程继承的环境变量表是我自己写的shell的环境变量表呢？
        execvpe(gargv[0], gargv, genv);// 把自己写的环境变量参数传给它
        // 在执行一个新的程序时，把命令行参数表、环境变量表都传给execvpe系统，
        // 所以自己的程序是父进程通过系统调用，把这两个参数交给了你的程序，
        // 程序执行时，就能获得这两个参数
        


        // 2. 退出
        exit(1);
    }
    
    // father
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        // Do Nothing
        return true;
    }
    return false;
}

void AddEnv(const char *item)
{
    int index = 0;
    while(genv[index])
    {
        index++;
    }
    // 指向为空的下标
    genv[index] = (char*)malloc(strlen(item)+1);// 不能使用局部的变量，要重新申请
    strncpy(genv[index], item, strlen(item)+1);

    genv[++index] = nullptr;
}

// shell自己执行命令，本质是shell调用自己的函数
bool CheckAndExexcBuiltCommand() // shell调用自己的内部函数，把自己的路径发生变化
{
    if(strcmp(gargv[0], "cd") == 0)
    {
        // 内建命令
        if(gargc == 2) // 
        {
            // 系统接口
            chdir(gargv[1]); // 切换路径
        }
        return true;
    } 
    else if(strcmp(gargv[0], "export") == 0)
    {
        // export也是内建命令
        if(gargc == 2)
        {
            AddEnv(gargv[1]);
        }
        return true;
    }
    else if(strcmp(gargv[0], "env") == 0)
    {
        for(int i=0; genv[i]; i++)
        {
            printf("%s\n",genv[i]);
        }
        return true;
    }
    return false; 
}

// 从系统里把系统环境变量拷一份到我的环境变量里面，模拟一下从配置文件里面去读
// 作为一个shell，获取环境变量应该从系统的配置文件来获取
// 我们现在是直接从父shell中获取环境变量
void InitEnv()
{
    // 从父进程获取环境变量
    extern char **environ;
    int index = 0;
    while(environ[index])
    {
        // 导入环境变量，实则就是向shell自己的环境变量表当中，进行插入一个新的环境变量
        // 即 再malloc 一段空间，让指针数组指向它对应的那个位置
        genv[index] = (char*)malloc(strlen(environ[index]+1));
        strncpy(genv[index], environ[index], strlen(environ[index])+1);
        index++;        
    }
    genv[index] = nullptr;
}

int main()
{
    InitEnv();
    char command_buffer[basesize];// 命令行缓冲区大小
    while(true)
    {
         PrintCommandLine();    // 1.命令行提示符
         
         // command_buffer --> 输出型参数
         if(!GetCommandLine(command_buffer, basesize))      // 2.获取用户命令
         {  // 依次获取每个子字符串
             continue;// 获取到空格继续获取
         }
         //printf("%s\n",command_buffer);

         // "ls -a -l -n" --> "ls" "-a" "-l" "-n" 拆成一个一个的子字符串
         ParseCommandLine(command_buffer, strlen(command_buffer));    // 3.分析命令
         //debug();

         // 先判断该命令是否是内建命令
         if(CheckAndExexcBuiltCommand())
         {
             continue;
         }
         
         ExecuteCommand();      // 4.执行命令   
    
    }

    return 0;
}

// 每个进程都有一个当前路径的概念，改变当前路径：chdir
// cd .. 就会改变子进程的路径，和父进程有什么联系？
// cd .. 改变当前路径，改变的是谁的？改变的是shell的工作路径还是子进程的工作路径？
// 改变shell的工作路径，当前路径一旦更改，我想让未来所有的指令都使用shell当前的路径，
// 剩下的子进程依旧会继承父进程的shell（父进程的工作路径），所以cd命令不能让子进程去更改
// 因为子进程跑完就会退出，shell当前的工作路径根本没改。
// 即如果是子进程执行cd，子进程退出后根本不能影响下一个命令所对应的路径，
// 我们要改的是我们shell的工作路径，再执行下一个命令、第二个第三个命令，
// 就会在新路径下去执行操作了
// 所以：在shell当中，
// 有些命令必须由子进程执行，
// 有些命令不能由子进程执行，要由shell自己执行 --- 内建命令 built command 
//
//
//
// shell自己的路径变了，我们自己所在的cwd是在进程的PCB当中的,pwd查找的时候也是在PCB里面的
// PWD是一个环境变量，所以 当路径发生变化时，要更新一下环境变量
//
// 我们自己的shell来维护环境变量表的话，echo、export【增加环境变量】就要从0开始实现
// 【内建命令】让自己的shell来修改自己的表
// 不能用子进程来导入环境变量，子进程不能影响当前的shell的
//
//
// 内建命令无法被子进程继承，环境变量可以，所以环境变量具有全局性
// echo 可以打印内建命令
//
//
//
// 1、在命令行中，一个命令是如何执行的？
// 对应普通命令来讲，就是解析命令行，然后通过exec*系列的函数接口，进行fork()进行程序替换。
// 2、什么是命令行参数表？是从命令行依次获取的，被shell自己解析自己维护的。
// 3、什么是环境变量表？从系统的配置文件读取出来的，由shell自己维护的，
// 维护好就是一个全局的指针数组，然后通过execvpe，
// 这个系统的调用接口把环境变量传递给所有的子进程
//
// echo命令，为什么是内建命令？a=100; echo $a
// 系统除了维护环境变量表、命令行参数表，还维护了一张本地变量表，
// 这张表无法通过exec*这样的接口传递给子进程，所以子进程看不到
// 在本地变量的这张表，让shell自己去维护，然后echo的时候，去打印就可以了
// 本地变量表属于在shell自己内部维护的全局数据当中的一个字符串。
//
